/*
 * Copyright (c) 2005-2008 旭鸣信息
 * All rights reserved. 
 *
 * File：TreeNodeFactory.java
 * History:
 *       2008-1-12: Initially created, tangkf.
 */
package com.xteam.utils;

import java.util.ArrayList;
import java.util.List;

import javax.swing.tree.DefaultMutableTreeNode;

import net.sf.json.JSONArray;
import net.sf.json.JSONException;
import net.sf.json.JSONObject;

import com.tangkf.utils.CommonUtils;

/**
 * <p>
 * 用来制造一个具有tree结构的树
 * </p>
 * @author tangkf
 */
public class TreeNodeUtils {

	/**
	 * 默认的ROOTID
	 */
	public static final String	ROOT_ID			= "0";

	/**
	 * 树图标关键字
	 */
	public static final String	TREE_ICON		= "icon";
	/**
	 * 树节点CSS样式名
	 */
	public static final String	TREE_FOLDER		= "e-tree-folder";
	/**
	 * 树叶子节点CSS样式名
	 */
	public static final String	TREE_GRIDE		= "app-btn-grid";
	/**
	 * 数据接口children 关键字
	 */
	public static final String	TREE_CHILDREN	= "children";

	/**
	 * 将一个递归结构链表转换为树形结构的Json数据格式并返回
	 * @author tangkf
	 * @param levellist 递归结构链表
	 * @param rootPID 根节点 的父ID
	 * @return
	 */
	public static JSONArray getJSONArrayTreeNode(List<?> levellist, String rootPID) {
		// 首先对链表进行类型转换，//TODO 或许还有更好的方法？
		List<LevelNode> srcList = convertLevelNodeList(levellist);

		JSONArray treeJson = new JSONArray();

		// 获取根节点列表，可能包含多个根
		List<LevelNode> plist = getListByParent(srcList, rootPID);
		if (CommonUtils.notEmpty(plist)) {
			// 递归节点
			for (LevelNode root : plist) {
				JSONObject jso = getChildrenJSON(srcList, root.getId());
				treeJson.add(jso);
			}
		}

		/*
		 * else { // 设置虚拟根节点 treeJson.add(createVirtualRootNode()); }
		 */

		return treeJson;
	}

	/**
	 * 将列表转换为 LevelNode 的列表,当然 这个源中的 对象 必须要实现 LevelNode 接口
	 * @author tangkf ---2012-1-31
	 * @param srcList 源，其中的对象 必须要实现 LevelNode 接口
	 * @return
	 */
	static List<LevelNode> convertLevelNodeList(List<?> srcList) {
		List<LevelNode> lns = new ArrayList<LevelNode>();
		for (Object obj : srcList) {
			if (obj instanceof LevelNode) {
				LevelNode nd = (LevelNode) obj;
				lns.add(nd);
			}
		}
		return lns;
	}

	/**
	 * 递归产生树结构
	 * @author tangkf
	 * @param list
	 * @param parentID
	 * @return
	 * @throws JSONException
	 */
	static JSONObject getChildrenJSON(List<LevelNode> list, String parentID) throws JSONException {
		// 取得父节点
		LevelNode parent = getNode(list, parentID);
		JSONObject parentJson = JSONObject.fromObject(parent);

		// 取得孩子链表
		List<LevelNode> childlist = getListByParent(list, parent.getId());
		if (CommonUtils.notEmpty(childlist)) {
			List<JSONObject> childrenJson = new ArrayList<JSONObject>();
			for (LevelNode node : childlist) {
				JSONObject child = getChildrenJSON(list, node.getId());
				if (child != null) {
					parentJson.put(TREE_ICON, TREE_FOLDER);
					parentJson.put("iconCls", TREE_FOLDER);
					childrenJson.add(child);
				}
			}
			if (CommonUtils.notEmpty(childrenJson)) parentJson.put(TREE_CHILDREN, childrenJson);
		} else {
			parentJson.put(TREE_ICON, TREE_GRIDE);
			parentJson.put("iconCls", TREE_GRIDE);
		}
		return parentJson;
	}

	/**
	 * <p>
	 * 由一个 List ,和一个根结点生成一课树
	 * </p>
	 * @author tangkf modify by 2008-8-7
	 * @param levellist 一个LIST 该LIST 中的元素必须实现了 LevelNode 接口
	 * @param rootnode 根元素,必须实现LevelNode 接口
	 * @return
	 */
	public static DefaultMutableTreeNode getDefaultMutableTreeNode(List<LevelNode> levellist, LevelNode rootnode) {
		DefaultMutableTreeNode treeNode = new DefaultMutableTreeNode();
		treeNode.setUserObject(rootnode);
		return getChildrenTreeList(levellist, treeNode);
	}

	/**
	 * <p>
	 * 由父亲结点生成他的所有孩子结点
	 * </p>
	 * @author tangkf
	 * @param levellist
	 * @param treenode
	 * @return
	 */
	static DefaultMutableTreeNode getChildrenTreeList(List<LevelNode> levellist, DefaultMutableTreeNode treenode) {
		LevelNode data = (LevelNode) treenode.getUserObject();
		List<LevelNode> childlist = getListByParent(levellist, data);
		if (childlist != null && childlist.size() > 0) {
			for (LevelNode ln : childlist) {
				DefaultMutableTreeNode child = new DefaultMutableTreeNode();
				child.setUserObject(ln);
				treenode.add(child);
				getChildrenTreeList(levellist, child);
			}
		}
		return treenode;
	}

	/**
	 * <p>
	 * 获取一个层级表中指定父亲ID下的一级孩子
	 * </p>
	 * @author tangkf
	 * @param levellist
	 * @param parent
	 * @return
	 */
	public static List<LevelNode> getListByParent(List<LevelNode> levellist, LevelNode parent) {
		List<LevelNode> rtnlst = null;
		if (levellist != null && levellist.size() > 0) {
			rtnlst = new ArrayList<LevelNode>();
			for (LevelNode ln : levellist) {
				if (ln.getPid().equals(parent.getId())) {
					rtnlst.add(ln);
				}
			}
		}
		return rtnlst;
	}

	/**
	 * 由ID获取下级孩子链表
	 * @author tangkf
	 * @param levellist
	 * @param pid
	 * @return
	 */
	public static List<LevelNode> getListByParent(List<LevelNode> levellist, String pid) {
		List<LevelNode> rtnlst = null;
		if (levellist != null && levellist.size() > 0) {
			rtnlst = new ArrayList<LevelNode>();
			for (LevelNode ln : levellist) {
				if (ln.getPid()!=null && ln.getPid().equals(pid)) {
					rtnlst.add(ln);
				}
			}
		}
		return rtnlst;
	}

	/**
	 * 获取制定ID的结点
	 * @author tangkf
	 * @param node
	 * @return
	 */
	public static LevelNode getNode(List<LevelNode> levellist, String id) {
		LevelNode node = null;
		if (levellist != null && levellist.size() > 0) {
			for (LevelNode ln : levellist) {
				if (ln.getId().equals(id)) {
					node = ln;
					break;
				}
			}
		}
		return node;
	}

	/**
	 * 模拟产生一个虚拟根节点，特殊性，ID为0 父ID为-1，由虚拟根产生的根节点父ID必定为 0
	 * @author tangkf
	 * @return
	 */
	public static JSONObject createVirtualRootNode() {
		JSONObject jso = new JSONObject();
		jso.put("id", "0");
		jso.put("pid", "-1");
		jso.put("name", "ROOT");
		jso.put("remark", "ROOT");
		jso.put("icon", "e-tree-folder");
		jso.put("iconCls", "e-tree-folder");
		return jso;
	}
}
